var CONFIG = require('../../../../../common/config');
var CODE = require('../../../../../common/code');
var async = require('async');
var moment = require('moment');
var retUtil = require('./retUtil');
var TgTypeModel=require('../../../../../common/mysql/mapping/TgTypeModel');
var ItbUserModel =require('../../../../../common/mysql/mapping/ItbUserModel');
var TgDesignDocModel =require('../../../../../common/mysql/mapping/TgDesignDocModel');
var TgKeywordModel=require('../../../../../common/mysql/mapping/TgKeywordModel');
var TgKeywordRModel=require('../../../../../common/mysql/mapping/TgKeywordRModel');
var TgReviewHisModel=require('../../../../../common/mysql/mapping/TgReviewHisModel');



var designsUtil = (function () {
    function designsUtil() {

    }

    /**
     * 创建/更新模板
     *
     * @deprecated by wangjun 2018-04-23 当前时间, 设计尚需依赖 page pc 结构, 当前方法未使用, 未处理, 留待备用
     *
     * @author 王俊
     * @date 2018-04-11
     *
     * @param {Object} options 请求参数
     * @param {Number} options.userId 作者 id
     * @param {Number} options.designKind 设计分类, 10 标记静态设计, 20 标记视频设计
     * @param {Number} options.designId 设计 id, 为0 标记新建
     * @param {Number} options.designName 模板名称
     * @param {Number} options.typeId 模板分类 id
     * @param {String} options.tg 模板提纲
     * @param {String} options.doc 模板文档
     * @param {String} [options.srcUrl] 模板源文件
     * @param {String} [options.typeset] 保存完毕是否需要排版
     * @param {Function} callback 回调
     */
    designsUtil.createOrUpdateDesign = function (options, callback) {

        var totalTasks = [];
        //1. 确认用户
        totalTasks.push(function (callback) {
            var opt = {
                queryType : 2,
                userId : options.userId
            };
            (new ItbUserModel()).getBackUserInfo(opt, function (error, userInfo) {
                if(error || !userInfo || userInfo.length <=0) {
                    return callback(error || '该用户不存在或权限不足');
                }
                if(!userInfo.yjscDesignPlatformInfo) {
                    return callback('权限不足, 创建模板失败', null);
                }
                // 用户角色(多角色用户按位与): 0普通用户, 1一级管理员, 2二级管理员, 4三级管理员, 8超级管理员, 16设计人员, 32模版操作员, 64印刷对接员, 128客服 , 256测试员, 512市场人员, 1024环信客服
                // 管理员+设计人员 1+2+4+8+16 = 31
                if(userInfo.yjscDesignPlatformInfo.role & 31 <=0) {
                    return callback('权限不足, 创建模板失败', null);
                }
                var data = {};
                data.userInfo = userInfo;
                return callback(error, data);
            });
        });
        //2. 新建模板
        totalTasks.push(function (data, callback) {
            if(options.designId && options.designId >0) {
                return callback(null, data);
            }
            designsUtil.createStaticDesign(options, function (error, result) {
                data.result = result;
                return callback(error, data);
            });
        });
        //3. 修改模板
        totalTasks.push(function (data, callback) {
            if(!options.designId || options.designId <=0) {
                return callback(null, data);
            }
            designsUtil.updateStaticDesign(options, function (error, result) {
                data.result = result;
                return callback(error, data);
            });
        });
        // 4. 若需要排版, 则排版后在返回
        totalTasks.push(function (data, callback) {
            if(!options.typeset) {
                return callback(null, data);
            }
            // 暂不处理排版
            return callback(null, data);
        });

        async.waterfall(totalTasks, function (error, data) {
            if(error) {
                return callback(error, null);
            }
            return callback(error, {designId : data.result.designId});
        });
    };

    /**
     * 创建静态设计
     *
     * @deprecated by wangjun 2018-04-23 当前时间, 设计尚需依赖 page pc 结构, 当前方法未使用, 未处理, 留待备用
     *
     * @author 王俊
     * @date 2018-04-11
     *
     * @param {Object} options 请求参数
     * @param {Number} options.userId 作者 id
     * @param {Number} options.designName 模板名称
     * @param {Number} options.typeId 模板分类 id
     * @param {String} options.tg 模板提纲
     * @param {String} options.doc 模板文档
     * @param {String} [options.srcUrl] 模板源文件
     * @param {Function} callback 回调
     */
    designsUtil.createStaticDesign = function (options, callback) {

        var sizeId = Number(CONFIG.YJSC_TGTYPE_SIZE_MAP[options.typeId]);
        if (!sizeId || isNaN(sizeId) || sizeId<=0) {
            return callback('暂未查询到该分类的尺寸, 创建失败', null);
        }
        var tgObj = retUtil.safe_parser_JSON_string(options.tg);
        if(!tgObj) return callback('提纲结构错误', null);
        var ver = tgObj.version;

        var designEntity = new  TgDesignDocModel({
            tg_id : 0,
            map_id : 0,
            design_name : options.designName,
            user_id : options.userId,
            data : options.tg,
            finetune_data : options.doc,
            size_id : sizeId,
            type_id : options.typeId,
            ver : ver,
            update_by : options.userId
        });
        if(options.srcUrl && options.srcUrl.length > 4) {
            designEntity.src_url = options.srcUrl;
        }
        designEntity.saveToDB(function (error, designId) {
            return callback(error, {designId : designId});
        });
    };
    /**
     * 更新静态设计
     *
     * @deprecated by wangjun 2018-04-23 当前时间, 设计尚需依赖 page pc 结构, 当前方法未使用, 未处理, 留待备用
     *
     * @author 王俊
     * @date 2018-04-11
     *
     * @param {Object} options 请求参数
     * @param {Number} options.userId 作者 id
     * @param {Number} options.designId 设计 id
     * @param {Number} options.designName 模板名称
     * @param {Number} options.typeId 模板分类 id
     * @param {String} options.tg 模板提纲
     * @param {String} options.doc 模板文档
     * @param {String} [options.srcUrl] 模板源文件
     * @param {Function} callback 回调
     */
    designsUtil.updateStaticDesign = function (options, callback) {

        var tasks = [];

        // 1. 先查询模板, 与当前用户对比
        tasks.push(function (callback) {
            var designEntity = new TgDesignDocModel({
                design_id : options.designId,
                del_flg : 0
            });
            designEntity.findFromDB(function (error, results) {
                if(error || !results || results.length <=0) {
                    return callback(error || '该模板不存在或已删除');
                }
                var data = {};
                data.designEntity = results[0];
                return callback(error, data);
            });
        });
        // 2. 逻辑拦截
        tasks.push(function (data, callback) {
            // 用户拦截
            if(data.designEntity.user_id !== options.userId) {
                return callback('不能修改非本用户模板', null);
            }
            // 状态拦截
            // '上架流程状态: 0未知;10制作中;20提交等待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败'
            if([20, 31, 32].indexOf(data.designEntity.state) >= 0) {
                return callback('审核中模板不可修改', null);
            }
            // 下架流程状态: 0未知;20提交下架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
            if([20, 31, 32].indexOf(data.designEntity.state2) >= 0) {
                return callback('审核中模板不可修改', null);
            }
            if(data.designEntity.publish === 1) {
                return callback('已上架模板不可修改', null);
            }
            return callback(null, data);
        });

        // 3. 真正修改
        tasks.push(function (data, callback) {
            var tgObj = retUtil.safe_parser_JSON_string(options.tg);
            if(!tgObj) return callback('提纲结构错误', null);
            var ver = tgObj.version;

            var designEntity = new  TgDesignDocModel({
                design_id : options.designId,
                design_name : options.designName,
                user_id : options.userId,
                data : options.tg,
                finetune_data : options.doc,
                state : 10, /**制作中*/
                ver : ver
            });
            if(options.srcUrl && options.srcUrl.length > 4) {
                designEntity.src_url = options.srcUrl;
            }
            designEntity.updateToDB(function (error) {
                return callback(error, data);
            });
        });
        // 顺序执行
        async.waterfall(tasks, function (error, data) {
            return callback(error, {designId : options.designId});
        });
    };

    /**
     * 创建视频设计
     *
     * @author 王俊
     * @date 2018-04-11
     *
     * @param {Object} options 请求参数
     * @param {Function} callback 回调
     */
    designsUtil.createVideoDesign = function (options, callback) {

        return callback('暂不支持创建视频模板', null);
    };
    /**
     * 更新视频设计
     *
     * @author 王俊
     * @date 2018-04-11
     *
     * @param {Object} options 请求参数
     * @param {Function} callback 回调
     */
    designsUtil.updateVideoDesign = function (options, callback) {
        return callback('暂不支持更新视频模板', null);
    };



  

    /**
     * 获取模板关键词列表
     *
     * @author 毛凯
     * @date 2018-4-11
     * @param   designId  设计模板id
     * @param   designKind  10 标记静态设计模板, 20 标记视频设计模板
     * @param   callback 回调
     *              err 错误信息
     *              data 返回数据
     * */
    designsUtil.getDesignKwds = function(designId,designKind,callback){
        if(designKind ==10){
            (new TgKeywordModel()).getDesignKwd(designId,function(err,keywords){
                if(err){
                    return callback(err,null);
                }
                var defList=[];
                var cusList=[];
                if(!keywords || keywords.length<=0){
                    return callback(null,{defList:defList|| [],cusList:cusList||[]});
                }
                for(var i = 0;i<keywords.length;i++){
                    var keyword = keywords[i];
                    var keyId = keyword.key_id;
                    var type = keyword.type;
                    var keyName = keyword.key_name;
                    //排除掉自定义的关键词id
                    if(type!=10 ){defList.push(keyId);}
                    //只获取自定义关键词
                    if(type == 10){cusList.push(keyName);}
                }
                return callback(null,{defList:defList|| [],cusList:cusList||[]});
            });
        }else{
             return callback(null,{});
        }
    };




    /**
     * 重置模板关键词
     *
     * @author 毛凯
     * @date 2018-4-11
     *
     * @param   userId  用户唯一标识
     * @param   designId  设计模板id
     * @param   defKeyIds 默认关键词的 id 数组 json
     * @param   cusKeys    用户自定义关键词列表(不超过四个)
     * @param   designKind  10 标记静态设计模板, 20 标记视频设计模板
     * @param   callback 回调
     *              err 错误信息
     *              data 返回数据
     * */
    designsUtil.updateDesignKeyword = function(userId,designId,defKeyIds,cusKeys,designKind,callback){
        if(designKind ==10){
            var tasks = [];
            var keyREntity = new TgKeywordRModel();
            var keyEntity = new TgKeywordModel();
            //验证权限
            tasks.push(function(callback){
                var entity = new ItbUserModel();
                var opt = {
                    queryType : 2,
                    userId : userId
                };
                entity.getBackUserInfo(opt, function (error, userInfo) {
                    if (error || !userInfo || !userInfo) {
                        return callback(error || '用户不存在或权限不足');
                    }
                    if(!userInfo.yjscDesignPlatformInfo) {
                        return callback('权限不足, 操作失败');
                    }
                    // 用户角色(多角色用户按位与): 0普通用户, 1一级管理员, 2二级管理员, 4三级管理员, 8超级管理员, 16设计人员, 32模版操作员, 64印刷对接员, 128客服 , 256测试员, 512市场人员, 1024环信客服
                    // 管理员 1+2+4+8 = 15
                    if((userInfo.yjscDesignPlatformInfo.role & 31) <=0) {
                        return callback('权限不足, 操作失败', null);
                    }
                    var data = {};
                    data.userInfo = userInfo;
                    return callback(error, data);
                });
            });
            //查看作品的用户id进行下一步权限认证
            tasks.push(function(data,callback){
                keyEntity.getDesignTopType(designId,function(err,topType) {
                    if (err) {
                        return callback(err, null);
                    }
                    data.topType = topType;
                    var desUser = topType[0].user_id ;
                    var role = data.userInfo.yjscDesignPlatformInfo.role;
                    if((desUser != userId && role & 15 <=0) || (desUser == userId && role & 16 <=0)){
                        return callback('权限不足, 操作失败', null);
                    }
                    return callback(err,data);
                });
            });
            //查询设计原topTypeId
            tasks.push(function(data,callback){
                keyEntity.getDesignTopType(designId,function(err,topType) {
                    if (err) {
                        return callback(err, null);
                    }
                    if(topType[0].publish == 1){
                        return callback("已上架模版无法修改关键词", null);
                    }
                    var data = {
                        topType :topType
                    };
                     return callback(err,data);
                });
            });
            //删除原信息
            tasks.push(function(data,callback){
                keyREntity.delDesignKeys(userId,designId,function(err,res){
                    if(err){
                        return callback(err,null);
                    }
                    return callback(err,data);
                });
            });
            //插入用户自定义关键词
            tasks.push(function(data,callback){
                if(!cusKeys || cusKeys.length<=0 || cusKeys.length>4){
                    data.defKeyIds = defKeyIds ;
                    return callback(null,data);
                }
                //先查询有无自定义关键词
                keyEntity.getNewDesignKwd(cusKeys,function(err,keyIdRes) {
                    if (err) {
                        return callback(err, null);
                    }
                    var exIds = [];
                    var keyName = [];
                    //判断所有关键词id取出没有的id
                    if(keyIdRes && keyIdRes.length>0){
                        for(var i=0;i< keyIdRes.length;++i){
                           var oneKeyWordInfo =  keyIdRes[i];
                            exIds.push(oneKeyWordInfo.key_id);
                            keyName.push(oneKeyWordInfo.key_name);
                        }
                        data.exIds = exIds;
                        if(exIds.length != cusKeys.length){
                            var notKeyName = chaji_array(cusKeys,keyName);
                            //取出没有的自定义关键词
                            data.notKeyName = notKeyName;
                            return callback(err, data);
                        }else{
                            return callback(err, data);
                        }
                    }else{
                        data.notKeyName = cusKeys;
                        return callback(err, data);
                    }
                });
            });
            //如果原数据无则进行插入
            tasks.push(function(data,callback){
                if(!data.notKeyName || data.notKeyName.length<= 0){
                    return callback(null,data);
                }
                //插入关键词
                keyEntity.insertNewDesignCusKeyword(userId, data.notKeyName, function (err, insCusRes) {
                    if (err) {
                        return callback(err, null);
                    }
                    return callback(err,data);
                });
            });
            //查询用户自定义关键词id
            tasks.push(function(data,callback){
                if(data.defKeyIds || !cusKeys || cusKeys.length<=0 || cusKeys.length>4){
                    return callback(null,data);
                }
                keyEntity.getNewDesignKwd(cusKeys,function(err,keyIdRes) {
                    if (err) {
                        return callback(err, null);
                    }
                    if(keyIdRes && keyIdRes.length>0) {
                        for (var i = 0; i < keyIdRes.length; i++) {
                            defKeyIds.push(keyIdRes[i].key_id);
                        }
                    }
                    data.defKeyIds = defKeyIds;
                    return callback(err,data);
                });
            });
            //插入关键词关联表中
            tasks.push(function(data,callback){
                var defKeyIds = data.defKeyIds;
                var type = data.topType[0].top_parent;
                if(!defKeyIds){
                    return callback(null,data);
                }
                keyREntity.insertNewDesignKeyword(userId,designId,defKeyIds,type,function(err,inserRes){
                    if(err){
                        return callback(err, null);
                    }
                    return callback(null,data);
                });

            });
            async.waterfall(tasks, function (error, data) {
                if(error || !data) {
                    return callback(error, null);
                }
                return callback(error, {});
            });
        }else{
            return callback(null,{});
        }
    };


    /**
     * 获取模板详情
     *
     * @author 毛凯
     * @date 2018-4-11
     * @param   designId  设计模板id
     * @param   designKind  10 标记静态设计模板, 20 标记视频设计模板
     * @param   callback 回调
     *              err 错误信息
     *              data 返回数据
     * */
    designsUtil.getDesignPreview = function(designId,designKind,callback){
        if(designKind ==10){

            var tasks = [];
            tasks.push(function(callback){
                (new TgDesignDocModel()).getDesignDetaile(designId,function(err,designRes){
                    if(err){
                        return callback(err,null);
                    }
                    if(!designRes || designRes.length<=0){
                        return callback("未获取到模板信息",null);
                    }
                    //初始化对象
                    var designInfo = {};
                    //循环建立对象属性
                    for(var i=0;i<designRes.length;i++){
                        var design = designRes[i];
                        if(!designInfo.designId){
                            designInfo.designKind = designKind;
                            designInfo.designId = design.designId;
                            designInfo.time = design.time;
                            designInfo.keywords = [];
                            designInfo.type = {} ;
                            designInfo.designName = design.designName;
                            designInfo.author= {
                                userId: design.userId,
                                userName: design.userName || "",
                                nickName: design.nickName || "",
                                headUrl: design.headUrl || ""
                            };
                            designInfo.image = {
                                    w : design.w || 0,
                                    h  : design.h || 0,
                                    thumbs : []
                            }
                        }
                        //添加图片到thumbs
                        designInfo.image.thumbs.push(design.thumbs);
                    }
                    var data ={
                        designInfo : designInfo
                    };
                    return callback(err,data);
                });
            });
            //查询模板关键词
            tasks.push(function(data,callback){
                (new TgKeywordModel()).getDesignKwd(designId,function(err,keywordRes){
                    if(err){
                        return callback(err,null);
                    }
                    data.keywordRes = keywordRes;
                    return callback(err,data);
                });
            });
            //查询分类
            tasks.push(function(data,callback){
                (new TgTypeModel()).getTypeInfoByDesignId(designId,function(err,typeRes){
                    if(err){
                        return callback(err,null);
                    }
                    var type = {};
                    var typeSub = {};
                    var typeSubs = {};
                    if(typeRes[0].top_parent){
                        type.typeId = typeRes[0].top_parent;
                        type.typeName = typeRes[0].typeLname;
                        type.children = [];
                    }
                    if(typeRes[0].top_parent && typeRes[0].parent){
                        typeSub.typeId = typeRes[0].parent;
                        typeSub.typeName = typeRes[0].typeMname;
                        typeSub.children = [];
                        type.children.push(typeSub);
                    }
                    if(typeRes[0].top_parent && typeRes[0].parent && typeRes[0].type_id){
                        typeSubs.typeId = typeRes[0].type_id;
                        typeSubs.typeName = typeRes[0].type_name;
                        typeSubs.children = [];
                        typeSub.children.push(typeSubs);
                    }
                    data.type = type;
                    return callback(err,data);
                });
            });

            async.waterfall(tasks, function (error, data) {
                if(error || !data) {
                    return callback(error, null);
                }
                for(var i = 0;i<data.keywordRes.length;i++){
                    var keyword = data.keywordRes[i];
                    data.designInfo.keywords.push(keyword.key_name);
                }
                data.designInfo.type =  data.type;
                return callback(error, data.designInfo || {});
            });
        }else{
            return callback(null,{});
        }
    };

    /**
     * 查询模板
     *
     * @author 王俊
     * @date 2018-04-12
     *
     * @param {Object} options 请求参数
     * @param {Number} options.userId 用户 id
     * @param {Array} options.designKinds 模板类型, 10 静态设计, 20 视频设计, 暂时只支持 [10]
     * @param {Number} options.check  是否是用于审核 0/1, 若用于审核则获取当前组织下所有模板
     * @param {Array} options.states 上架流程模板状态数组, 空数组标记不限
     * @param {Array} options.state2s 下架流程模板状态数组, 空数组标记不限
     * @param {Array} options.publish 模板发布标记, 0 标记未上架状态, 1 标记下架状态, 空数组标记不限
     * @param {Number} options.pageNum 页码
     * @param {Number} options.pageSize 页容量
     * @param {Number} options.withTotalPage 是否获取总页数
     * @param {Function} callback 请求回调
     *                      error: 查询失败
     *                      data: {
     *                          list : 列表,
     *                          totalPage: 总页数
     *                          totalCnt
     *                      }
     */
    designsUtil.filterDesigns = function (options, callback) {

        var totalTasks = [];
        // 1. 检查权限
        totalTasks.push(function (callback) {
            var opt = {
                queryType : 2,
                userId : options.userId
            };
            var entity = new ItbUserModel();
            entity.getBackUserInfo(opt, function (error, userInfo) {
                if(error || !userInfo) {
                    return callback(error || '该用户不存在或权限不足', null);
                }
                if(!userInfo.yjscDesignPlatformInfo) {
                    return callback('权限不足, 操作失败', null);
                }
                var data = {};
                data.userInfo = userInfo;
                // 如果是 check 要求是管理权限
                // 用户角色(多角色用户按位与): 0普通用户, 1一级管理员, 2二级管理员, 4三级管理员, 8超级管理员, 16设计人员, 32模版操作员, 64印刷对接员, 128客服 , 256测试员, 512市场人员, 1024环信客服
                // 管理员 1+2+4+8 = 15
                var isAdmin = userInfo.yjscDesignPlatformInfo.role & 15;
                var isDesigner = userInfo.yjscDesignPlatformInfo.role & 16;
                // 检查 并且是 管理员
                if(options.check && isAdmin) {
                    return callback(null, data);
                }
                // 是设计师或管理员
                if(isAdmin || isDesigner) {
                    return callback(null, data);
                }
                return callback('权限不足, 操作失败', null);
            });
        });
        // 2. 查询列表
        totalTasks.push(function (data, callback) {

            var entity = new TgDesignDocModel();
            // 查组织内模板
            if(options.check) {
                options.orgId = data.userInfo.yjscDesignPlatformInfo.orgId;
                entity.getOrgUserDesigns(options, function (error, results) {
                    data.list = results;
                    return callback(error, data);
                });
                return;
            }
            // 查当前用户的模板
            entity.getUserDesigns(options, function (error, results) {
                data.list = results;
                return callback(error, data);
            });
        });
        // 3. 查询个数
        totalTasks.push(function (data, callback) {
            if(!options.withTotalPage) {
                return callback(null, data);
            }
            var entity = new TgDesignDocModel();
            // 查组织内模板
            if(options.check) {
                entity.getOrgUserDesignsCnt(options, function (error, count) {
                    data.totalCnt = count;
                    data.totalPage = Math.floor((count-1)/options.pageSize)+1;
                    return callback(error, data);
                });
                return;
            }
            // 查当前用户的模板
            entity.getUserDesignsCnt(options, function (error, count) {
                data.totalCnt = count;
                data.totalPage = Math.floor((count-1)/options.pageSize)+1;
                return callback(error, data);
            });
        });
        // 4. 并发获取失败消息
        totalTasks.push(function (data, callback) {
            if(!data.list && data.list.length <= 0) {
                return callback(null, data);
            }
            var tasks = [];
            for(var i=0; i<data.list.length; i++) {
                var t = (function (index) {
                    var design = data.list[index];
                    // 上架审核失败
                    // 上架流程状态: 0未知;10制作中;20提交等待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
                    var publishFailStates = [41, 42];
                    if(design.publish === 0 && publishFailStates.indexOf(design.state) >=0) {
                        return function (callback) {
                            var opt = {
                                kind : design.design_kind,
                                design_id : design.design_id,
                                state_type : 1, // 上架流程审核记录
                                state : design.state,
                                del_flg : 0
                            };
                            var entity = new TgReviewHisModel();
                            entity.getLatestReviewHistory(opt, function (error, history) {
                                if(history) design.ng_msg = history.content;
                                return callback(error, null);
                            });
                        }
                    }
                    // 下架审核失败
                    // 下架流程状态: 0未知;20提交下架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
                    if(design.publish === 1 && [20, 41, 42].indexOf(design.state2) >=0) {
                        return function (callback) {
                            var opt = {
                                kind : design.design_kind,
                                design_id : design.design_id,
                                state_type : 2, // 上架流程审核记录
                                state : design.state2
                            };
                            var entity = new TgReviewHisModel();
                            entity.getLatestReviewHistory(opt, function (error, history) {
                                if(history) design.ng_msg = history.content;

                                // 获取下架申请原因
                                var opt2 = {
                                    kind : design.design_kind,
                                    design_id : design.design_id,
                                    state_type : 2, // 上架流程审核记录
                                    state : 20     // 申请下架原因
                                };
                                var applyEntity = new TgReviewHisModel();
                                applyEntity.getLatestReviewHistory(opt2, function (error, apply) {
                                    if(apply) design.apply_msg = apply.content;
                                    return callback(error, null);
                                });
                            })
                        }
                    }

                    return null;
                })(i);
                if(t) tasks.push(t);
            }
            async.parallelLimit(tasks, 3, function (error, result) {
                return callback(error, data);
            });
        });
        async.waterfall(totalTasks, function (error, data) {
            if(error) {
                return callback(error, null);
            }
            var ret = {
                list : data.list || [],
                totalCnt : data.totalCnt,
                totalPage : data.totalPage
            };
            return callback(error, ret);
        });
    };
    /**
     * 获取模板上架失败/申请加下失败原因信息
     *
     * @author 王俊
     * @date 2018-04-12
     *
     * @param {Object} options 请求参数
     * @param {Object} options.designKind 模板类型 10 标记静态模板, 20 标记视频模板
     * @param {Object} options.designId 模板标识
     * @param {Object} options.state 上架状态
     * @param {Object} options.state2 下架状态
     * @param {Object} options.publish 模板发布状态
     * @param {Function} callback 回调函数
     */
    designsUtil.getDesignReviewHistoryContent = function (options, callback) {
        var design = data.list[index];
        // 上架审核失败
        // 上架流程状态: 0未知;10制作中;20提交等待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
        var publishFailStates = [41, 42];
        if(design.publish === 0 && publishFailStates.indexOf(design.state) >=0) {
            return function (callback) {
                var entity = new TgReviewHisModel({
                    kind : design.design_kind,
                    design_id : design.design_id,
                    state_type : 1, // 上架流程审核记录
                    state : design.state,
                    del_flg : 0
                });
                entity.findFromDB(function (error, historys) {
                    if(error) {
                        return callback(error);
                    }
                    if(historys && historys.length>0) {
                        design.ng_msg = historys[0].content
                    }
                    return callback(error, null);
                })
            }
        }
        // 下架审核失败
        // 下架流程状态: 0未知;20提交下架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
        var unPublishFailStates = [41, 42];
        if(design.publish === 1 && unPublishFailStates.indexOf(design.state2) >=0) {
            return function (callback) {
                var entity = new TgReviewHisModel({
                    kind : design.design_kind,
                    design_id : design.design_id,
                    state_type : 1, // 上架流程审核记录
                    state : design.state,
                    del_flg : 0
                });
                entity.findFromDB(function (error, historys) {
                    if(error) {
                        return callback(error);
                    }
                    if(historys && historys.length>0) {
                        design.ng_msg = historys[0].content
                    }

                    // 获取下架申请原因




                    return callback(error, null);
                })
            }
        }


    };

    /**
     * 获取模板统计数据
     *
     * @author 毛凯
     * @date 2018-4-11
     * @param   userId  用户唯一标识
     * @param   accounts  设计师账户数组对应的 json 字符串, 不传默认全部
     * @param   beginTime 开始时间戳, 秒级, 不传默认平台开发时的时间戳
     * @param   endTime   结束时间戳, 秒级, 不传默认服务器当前时间
     * @param   callback 回调
     *              err 错误信息
     *              data 返回数据
     * */
    designsUtil.designStatistics = function(userId,accounts,beginTime,endTime,callback){
        var entity = new TgDesignDocModel();
        var usreEntity = new ItbUserModel();
        //初始化开始时间当为传时间使用改时间查询
        var strtime = '2016-04-23 0:0:0';
        var date = new Date(strtime);
        var time = Date.parse(date)/1000;
        var tasks = [];
        //获取用户当前用户的信息,组织id等
        tasks.push(function(callback){
            var option ={
                queryType : 2,
                userId : userId
            };
            usreEntity.getBackUserInfo(option,function(err,userInfo) {
                if (err || !userInfo || !userInfo) {
                    return callback(error || '用户不存在或权限不足');
                }
                if (userInfo.userType != 0) {
                    return callback("用户不存在或权限不足", null);
                }
                var data = {
                    userInfo : userInfo
                };
                return callback(err,data);
            });
        });
        //如果搜索模板统计传了用户名,查询该用户的用户id,返回用户id数组
        tasks.push(function (data, callback) {
            if(!accounts || accounts.length<=0){
                return callback(null,data);
            }
            usreEntity.getUserIdByName(accounts,function(err,userIdres){
                if(err){
                    return callback(err,data);
                }
                if(!userIdres || userIdres.length<=0){
                    return callback(err,data);
                }
                data.userIdList = [];
                for(var i = 0;i < userIdres.length;i++){
                    data.userIdList.push(userIdres[i].user_id);
                }
                return callback(null,data);
            });
        });
        //查询组织下,上架模板统计信息
        tasks.push(function(data,callback){
            var names = [];
            if(data.userIdList){
                names = data.userIdList;
            }
            //如果没传使用初始化开始时间
            var startTime = beginTime || time;
            //只传了开始时间结束时间默认为当前时间
            var endstamp = endTime || new moment().unix();
            var orgId = data.userInfo.yjscDesignPlatformInfo.orgId;
            entity.countPublishDesign(names,startTime,endstamp,orgId,function(err,puData){
                if(err){
                    return callback(err,null);
                }
                data.publish = puData;
                return callback(null,data);
            });
        });
        //查询组织下,下架模板统计
        tasks.push(function(data,callback){
            var names = [];
            if(data.userIdList){
                names = data.userIdList;
            }
            //如果没传使用初始化开始时间
            var startTime = beginTime || time;
            //只传了开始时间结束时间默认为当前时间
            var endstamp = endTime || new moment().unix();
            var orgId = data.userInfo.yjscDesignPlatformInfo.orgId;
            entity.countUnPublishDesign(names,startTime,endstamp,orgId,function(err,unpuData){
                if(err){
                    return callback(err,null);
                }
                data.unPublish = unpuData;
                return callback(null,data);
            });
        });
        async.waterfall(tasks,function(err,result){
            if(err){
                return callback(err,null);
            }
            //组织数据结构
            var data ={
                publish : result.publish[0] || {},
                unPublish : result.unPublish[0]|| {}
            };
            return callback(null,data);
        });

    };


    /***
     * 管理员审核模版
     * @author 李强
     * @date 2018-4-13
     * 方式: GET
     * 参数: userId   用户唯一标识
     * 参数: designId   设计id
     * 参数: designKind    10 标记静态设计模板, 20 标记视频设计模板
     * 参数: remark  审核备注, 标记打回原因, 审核通过可传固定值
     * 参数: state 审核状态, 1, 审核通过, 2, 审核打回
     * 参数: kind 1 上架审核, 2 下架审核
     */
    designsUtil.checkDesign = function(userId,designId,designKind,remark,state,kind,callback){
        if(designKind ==10){
            var tasks = [];
            var opstate = null;
            //审核状态
            if(state == 1){
                opstate = 31;
            }else{
                opstate = 41;
            }
            // 1. 查询模版信息
            tasks.push(function (callback) {
                var designEntity = new TgDesignDocModel({
                    design_id : designId,
                    del_flg : 0
                });
                designEntity.findFromDB(function (error, results) {
                    if(error || !results || results.length <=0) {
                        return callback(error || '该模板不存在或已删除');
                    }
                    var data = {};
                    data.designEntity = results[0];
                    return callback(error, data);
                });
            });

            // 2. 逻辑拦截
            tasks.push(function (data,callback) {
                // 状态拦截
                // '上架流程状态: 0未知;10制作中;20提交等待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败'
                if((data.designEntity.state != 20) && kind == 1) {
                    return callback('非等待审核模板不可进行审核', null);
                }
                // 下架流程状态: 0未知;20提交下架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
                if((data.designEntity.state2 != 20) && kind == 2) {
                    return callback('非等待审核模板不可进行审核', null);
                }
                return callback(null, data);
            });


            //3. 更新模版审核状态
            tasks.push(function (data, callback) {
                var designEntity = new  TgDesignDocModel({
                    design_id : designId
                });
                if(kind == 1){
                    //上架审核
                    designEntity.state = opstate;
                }else{
                    //下架审核
                    designEntity.state2 = opstate;
                }
                designEntity.updateToDB(function (error) {
                    return callback(error, data);
                });
            });

            // 4 . 添加审核历史记录
            tasks.push(function (data, callback) {
                var TgReviewHis = new TgReviewHisModel({
                    kind:designKind,
                    design_id:designId,
                    state_type:kind,
                    state:opstate,
                    content:remark,
                    reviewer:userId,
                    update_by:userId
                });
                TgReviewHis.saveToDB(function (error, id) {
                    return callback(error, data);
                });
            });

            // 顺序执行
            async.waterfall(tasks, function (error, data) {
                return callback(error, {designId : designId});
            });
        }else{
            return callback(null,{});
        }
    };




    /***
     * 提交模板状态变更申请
     * @author 李强
     * @date 2018-4-13
     * 方式: GET
     * 参数: userId   用户唯一标识
     * 参数: designId   设计id
     * 参数: designKind    10 标记静态设计模板, 20 标记视频设计模板
     * 参数: remark  审核备注, 标记申请下架原因 提交上架申请可传固定值
     * 参数: kind 1 上架, 2 下架
     *测试地址 : http://localhost:3000/yjsc/yjscPlatform/design/v1/designs/requestDesignCheck
     */
    designsUtil.requestDesignCheck = function(userId,designId,designKind,remark,kind,callback){
        if(designKind ==10){
            var tasks = [];
            // 1. 查询模版信息
            tasks.push(function (callback) {
                var designEntity = new TgDesignDocModel({
                    design_id : designId,
                    del_flg : 0
                });
                designEntity.findFromDB(function (error, results) {
                    if(error || !results || results.length <=0) {
                        return callback(error || '该模板不存在或已删除');
                    }
                    var data = {};
                    data.designEntity = results[0];
                    return callback(error, data);
                });
            });

            // 2. 逻辑拦截
            tasks.push(function (data,callback) {
                // 用户拦截
                if(data.designEntity.user_id !== userId) {
                    return callback('不能修改非本用户模板', null);
                }
                //上架判断
                // 上架流程状态: 0未知;20提交上架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
                if(kind ==1){
                    if(data.designEntity.publish== 1){
                        return callback('已上架模版不可进行提交申请', null);
                    }
                    if([20,31,32].indexOf(data.designEntity.state)>=0){
                        return callback("不可重复提交上架申请", null);
                    }
                    return callback(null,data);
                }
                //下架判断
                // 下架流程状态: 0未知;20提交下架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败
                if(data.designEntity.publish!=1){
                    return callback('非上架模版不可进行下架申请', null);
                }
                if([20,31,32].indexOf(data.designEntity.state2)>=0){
                    return callback("不可重复提交下架申请", null);
                }
                return callback(null, data);
            });


            //3. 更新模版审核状态
            tasks.push(function (data, callback) {
                var designEntity = new  TgDesignDocModel({
                    design_id : designId
                });
                if(kind == 1){
                    //提交上架审核
                    designEntity.state = 20;
                }else{
                    //提交下架审核
                    designEntity.state2 = 20;
                }
                designEntity.updateToDB(function (error) {
                    return callback(error, data);
                });
            });

            // 4 . 添加审核历史记录
            tasks.push(function (data, callback) {
                var TgReviewHis = new TgReviewHisModel({
                    kind:designKind,
                    design_id:designId,
                    state_type:kind,
                    state:20,
                    content:remark,
                    reviewer:userId,
                    update_by:userId
                });
                TgReviewHis.saveToDB(function (error, id) {
                    return callback(error, data);
                });
            });

            // 顺序执行
            async.waterfall(tasks, function (error, data) {
                return callback(error, {designId : designId});
            });
        }else{
            return callback(null,{});
        }
    };

    //计算两数组差集
    function chaji_array(arr1,arr2) {
        var arr3 = [];

        for (var i = 0; i < arr1.length; i++) {
            var flag = true;
            for (var j = 0; j < arr2.length; j++) {
                if (arr2[j] == arr1[i]) {
                    flag = false;
                }
            }
            if (flag) {
                arr3.push(arr1[i]);
            }
        }

        return arr3;
    }

    /***
     * 删除设计模板
     * @author 李强
     * @date 2018-5-30
     * 方式: GET
     * 参数: userId   用户唯一标识
     * 参数: designId  设计id
     * 测试地址 : http://114.55.172.253:7000/mock/107/yjsc/yjscPlatform/design/v1/designs/deleteDesignDoc
     */
    designsUtil.deleteDesignDoc = function(userId,designId,callback) {
        var tasks = [];
        // 1. 查询模版信息
        tasks.push(function (callback) {
            var designEntity = new TgDesignDocModel({
                design_id: designId,
                del_flg: 0
            });
            designEntity.findFromDB(function (error, results) {
                if (error || !results || results.length <= 0) {
                    return callback(error || '该模板不存在或已删除');
                }
                var data = {};
                data.designEntity = results[0];
                return callback(error, data);
            });
        });

        // 2. 逻辑拦截
        tasks.push(function (data, callback) {
            // 用户拦截
            if (data.designEntity.user_id !== userId) {
                return callback('不能删除非本用户模板', null);
            }
            //上架判断
            // 上架流程状态: 0未知;20提交上架申请待审核;31一级审核通过,32二级审核通过;41一级审核失败,42二级审核失败

            if (data.designEntity.publish == 1) {
                return callback('已上架模版不可删除', null);
            }

            if ([20, 31].indexOf(data.designEntity.state) >= 0) {
                return callback("非可编辑模板不可删除", null);
            }

            if (data.designEntity.state == 32 && data.designEntity.state2 != 32) {
                return callback("非可编辑模板不可删除", null);
            }

            return callback(null, data);
        });

        // 3 .删除模板
        tasks.push(function (data, callback) {
            var designEntity = new TgDesignDocModel({
                design_id: designId,
                user_id: userId,
                update_by: userId,
                del_flg: 1
            });

            designEntity.updateToDB(function (error) {
                return callback(error, data);
            });
        });

        // 顺序执行
        async.waterfall(tasks, function (error, data) {
            return callback(error, {designId: designId});
        });

    }



    return designsUtil;
})();


module.exports = designsUtil;